/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package b_and_b_properties;

import b_and_b_properties.data.DAO;
import b_and_b_properties.data.Property;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import javax.swing.DefaultListModel;
import javax.swing.JCheckBox;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.ListSelectionModel;
import javax.swing.SwingConstants;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;

/**
 *
 * @author Student
 */
public class PropertyFeaturesPanel extends JPanel implements ListSelectionListener, ActionListener {

    private CheckBoxConverter amenitiesCBConverter;
    private CheckBoxConverter appCBConverter;
    private CheckBoxConverter basementCBConverter;
    private CheckBoxConverter buildingCBConverter;
    private CheckBoxConverter documentsCBConverter;
    private CheckBoxConverter insideFeatCBConverter;
    private CheckBoxConverter miscCBConverter;
    private CheckBoxConverter outsideFeatCBConverter;
    private CheckBoxConverter viewCBConverter;
    private CheckBoxConverter zoningCBConverter;
    private JPanel zoningPanel;
    protected DefaultListModel roomList;
    protected JList roomListHolder;
    protected JScrollPane listScroller;
    protected JCheckBox amenitiesElectricCheckBox;
    protected JCheckBox amenitiesGasCheckBox;
    protected JCheckBox amenitiesHeatCheckBox;
    protected JCheckBox amenitiesLandscapingCheckBox;
    protected JCheckBox amenitiesMaintenanceCheckBox;
    protected JCheckBox amenitiesPlayAreaCheckBox;
    protected JCheckBox amenitiesPoolCheckBox;
    protected JCheckBox amenitiesSecurityAlarmCheckBox;
    protected JCheckBox amenitiesTrashCheckBox;
    protected JCheckBox amenitiesWaterCheckBox;
    protected JCheckBox appCompactorCheckBox;
    protected JCheckBox appDishWasherCheckBox;
    protected JCheckBox appDryerCheckBox;
    protected JCheckBox appGarbageDishCheckBox;
    protected JCheckBox appMicrowaveCheckBox;
    protected JCheckBox appOvenCheckBox;
    protected JCheckBox appRefrigeratorCheckBox;
    protected JCheckBox appWasherCheckBox;
    protected JCheckBox basementConcreteFloorCheckBox;
    protected JCheckBox basementFinsihedCheckBox;
    protected JCheckBox basementFireplaceCheckBox;
    protected JCheckBox basementGlassBlkWindCheckBox;
    protected JCheckBox basementLaminateFloorCheckBox;
    protected JCheckBox basementPartFinishedCheckBox;
    protected JCheckBox basementUnfinishedCheckBox;
    protected JCheckBox basementVinylFloorCheckBox;
    protected JCheckBox basementWalkoutCheckBox;
    protected JCheckBox basementWWCarpetCheckBox;
    protected JCheckBox buildingBarnCheckBox;
    protected JCheckBox buildingGazeboCheckBox;
    protected JCheckBox buildingStorageCheckBox;
    protected JCheckBox documentsAerialCheckBox;
    protected JCheckBox documentsBuildingRestricCheckBox;
    protected JCheckBox documentsDeedRestricCheckBox;
    protected JCheckBox documentsFeasibilityCheckBox;
    protected JCheckBox documentsHOACheckBox;
    protected JCheckBox documentsLeadPaintCheckBox;
    protected JCheckBox documentsPlanCheckBox;
    protected JCheckBox documentsRentalAppCheckBox;
    protected JCheckBox documentsSampleLeaseCheckBox;
    protected JCheckBox documentsSitePlanCheckBox;
    protected JCheckBox documentsSoilMapCheckBox;
    protected JCheckBox documentsSoilSurvCheckBox;
    protected JCheckBox documentsSurveyCheckBox;
    protected JCheckBox insideFeatBeamCeilingCheckBox;
    protected JCheckBox insideFeatBonusRoomCheckBox;
    protected JCheckBox insideFeatCathCeilingCheckBox;
    protected JCheckBox insideFeatCrownMoldingCheckBox;
    protected JCheckBox insideFeatFrechDoorCheckBox;
    protected JCheckBox insideFeatGreatRoomCheckBox;
    protected JCheckBox insideFeatLoftCheckBox;
    protected JCheckBox insideFeatMediaRoomCheckBox;
    protected JCheckBox insideFeatMultiPanelCheckBox;
    protected JCheckBox insideFeatNaturalWoodworkCheckBox;
    protected JCheckBox insideFeatNineFootCheckBox;
    protected JCheckBox insideFeatRecessCeilingCheckBox;
    protected JCheckBox insideFeatSolariumCheckBox;
    protected JCheckBox insideFeatVaultCeilingCheckBox;
    protected JCheckBox miscAirCleanerCheckBox;
    protected JCheckBox miscCableTvCheckBox;
    protected JCheckBox miscCeilingFanCheckBox;
    protected JCheckBox miscCoinLaundryCheckBox;
    protected JCheckBox miscDehumidifierCheckBox;
    protected JCheckBox miscFountainCheckBox;
    protected JCheckBox miscGarageDoorOpenerCheckBox;
    protected JCheckBox miscHighTextWiringCheckBox;
    protected JCheckBox miscRecessLightCheckBox;
    protected JCheckBox miscSmokeAlarmCheckBox;
    protected JCheckBox miscSumpPumpCheckBox;
    protected JCheckBox miscWaterSoftenerCheckBox;
    protected JCheckBox outsideFeatBalconyCheckBox;
    protected JCheckBox outsideFeatCornerLotCheckBox;
    protected JCheckBox outsideFeatCoveredDeckCheckBox;
    protected JCheckBox outsideFeatCulDeSacCheckBox;
    protected JCheckBox outsideFeatDeckCheckBox;
    protected JCheckBox outsideFeatEnclPorchCheckBox;
    protected JCheckBox outsideFeatFlagLotCheckBox;
    protected JCheckBox outsideFeatHotTubCheckBox;
    protected JCheckBox outsideFeatInvisibleFenceCheckBox;
    protected JCheckBox outsideFeatMetalFenceCheckBox;
    protected JCheckBox outsideFeatPatioCheckBox;
    protected JCheckBox outsideFeatPoolAboveCheckBox;
    protected JCheckBox outsideFeatPoolIngroundCheckBox;
    protected JCheckBox outsideFeatPorchCheckBox;
    protected JCheckBox outsideFeatPrivacyFenceCheckBox;
    protected JCheckBox outsideFeatSprinklersCheckBox;
    protected JCheckBox outsideFeatTennisCourtCheckBox;
    protected JCheckBox outsideFeatTieredDeckCheckBox;
    protected JCheckBox outsideFeatVinylFenceCheckBox;
    protected JCheckBox outsideFeatWoodedLotCheckBox;
    protected JCheckBox outsideFeatWoodFenceCheckBox;
    protected JCheckBox outsideFeatYardLightsCheckBox;
    protected JCheckBox viewCityCheckBox;
    protected JCheckBox viewLakeCheckBox;
    protected JCheckBox viewParkCheckBox;
    protected JCheckBox viewRiverCheckBox;
    protected JCheckBox viewWoodsCheckBox;
    protected JCheckBox zoningBusinessCheckBox;
    protected JCheckBox zoningCommercialCheckBox;
    protected JCheckBox zoningIndustrialCheckBox;
    protected JCheckBox zoningMobileHomeCheckBox;
    protected JCheckBox zoningMultiFamilyCheckBox;
    protected JCheckBox zoningNonconformingCheckBox;
    protected JCheckBox zoningOfficeCheckBox;
    protected JCheckBox zoningResidentialCheckBox;
    protected JCheckBox zoningUnzonedCheckBox;
    protected JLabel amenitiesLabel;
    protected JLabel applianceLabel;
    protected JLabel basementLabel;
    protected JLabel buildingLabel;
    protected JLabel documentsLabel;
    protected JLabel insideFeaturesLabel;
    protected JLabel miscLabel;
    protected JLabel outsideFeaturesLabel;
    protected JLabel viewLabel;
    protected JPanel amenitiesPanel;
    protected JPanel appliancePanel;
    protected JPanel basementPanel;
    protected JPanel buildingPanel;
    protected JPanel documentsPanel;
    protected JPanel insideFeaturesPanel;
    protected JPanel miscPanel;
    protected JPanel outsideFeaturesPanel;
    protected JPanel propertFeaturePanel;
    protected JPanel viewPanel;
    private DAO daoObject;
    private Property propertyObject;
    private JPanel topLeft = new JPanel();
    private JPanel topRight = new JPanel();

    public PropertyFeaturesPanel(DAO daoObject, Property prop) {
        this.daoObject = daoObject;
        this.propertyObject = prop;
        initComponents();
        createRoomList();
        createBasementPanel();
        createAppliancePanel();
        createAmenitiesPanel();
        createBuildingPanel();
        createDocumentsPanel();
        createInsideFeaturesPanel();
        createMiscPanel();
        createOutsidePanel();
        createViewPanel();
        createZoningPanel();
        createTopLeftPanel();
        createFeaturesPanel();
        amenitiesElectricCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (amenitiesElectricCheckBox.isSelected()) {
                    amenitiesCBConverter.set(CheckBoxConverter.BOX1);
                } else {
                    amenitiesCBConverter.clear(CheckBoxConverter.BOX1);
                }
            }
        });
        amenitiesGasCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (amenitiesGasCheckBox.isSelected()) {
                    amenitiesCBConverter.set(CheckBoxConverter.BOX2);
                } else {
                    amenitiesCBConverter.clear(CheckBoxConverter.BOX2);
                }
            }
        });
        amenitiesHeatCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (amenitiesHeatCheckBox.isSelected()) {
                    amenitiesCBConverter.set(CheckBoxConverter.BOX3);
                } else {
                    amenitiesCBConverter.clear(CheckBoxConverter.BOX3);
                }
            }
        });
        amenitiesLandscapingCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (amenitiesLandscapingCheckBox.isSelected()) {
                    amenitiesCBConverter.set(CheckBoxConverter.BOX4);
                } else {
                    amenitiesCBConverter.clear(CheckBoxConverter.BOX4);
                }
            }
        });
        amenitiesMaintenanceCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (amenitiesMaintenanceCheckBox.isSelected()) {
                    amenitiesCBConverter.set(CheckBoxConverter.BOX5);
                } else {
                    amenitiesCBConverter.clear(CheckBoxConverter.BOX5);
                }
            }
        });
        amenitiesPoolCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (amenitiesPoolCheckBox.isSelected()) {
                    amenitiesCBConverter.set(CheckBoxConverter.BOX6);
                } else {
                    amenitiesCBConverter.clear(CheckBoxConverter.BOX6);
                }
            }
        });
        amenitiesTrashCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (amenitiesTrashCheckBox.isSelected()) {
                    amenitiesCBConverter.set(CheckBoxConverter.BOX7);
                } else {
                    amenitiesCBConverter.clear(CheckBoxConverter.BOX7);
                }
            }
        });
        amenitiesWaterCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (amenitiesWaterCheckBox.isSelected()) {
                    amenitiesCBConverter.set(CheckBoxConverter.BOX8);
                } else {
                    amenitiesCBConverter.clear(CheckBoxConverter.BOX8);
                }
            }
        });
        amenitiesPlayAreaCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (amenitiesPlayAreaCheckBox.isSelected()) {
                    amenitiesCBConverter.set(CheckBoxConverter.BOX9);
                } else {
                    amenitiesCBConverter.clear(CheckBoxConverter.BOX9);
                }
            }
        });
        amenitiesSecurityAlarmCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (amenitiesSecurityAlarmCheckBox.isSelected()) {
                    amenitiesCBConverter.set(CheckBoxConverter.BOX9);
                } else {
                    amenitiesCBConverter.clear(CheckBoxConverter.BOX9);
                }
            }
        });
        appCompactorCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (appCompactorCheckBox.isSelected()) {
                    appCBConverter.set(CheckBoxConverter.BOX1);
                } else {
                    appCBConverter.clear(CheckBoxConverter.BOX1);
                }
            }
        });
        appDishWasherCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (appDishWasherCheckBox.isSelected()) {
                    appCBConverter.set(CheckBoxConverter.BOX2);
                } else {
                    appCBConverter.clear(CheckBoxConverter.BOX2);
                }
            }
        });
        appDryerCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (appDryerCheckBox.isSelected()) {
                    appCBConverter.set(CheckBoxConverter.BOX3);
                } else {
                    appCBConverter.clear(CheckBoxConverter.BOX3);
                }
            }
        });
        appGarbageDishCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (appGarbageDishCheckBox.isSelected()) {
                    appCBConverter.set(CheckBoxConverter.BOX4);
                } else {
                    appCBConverter.clear(CheckBoxConverter.BOX4);
                }
            }
        });
        appOvenCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (appOvenCheckBox.isSelected()) {
                    appCBConverter.set(CheckBoxConverter.BOX5);
                } else {
                    appCBConverter.clear(CheckBoxConverter.BOX5);
                }
            }
        });
        appMicrowaveCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (appMicrowaveCheckBox.isSelected()) {
                    appCBConverter.set(CheckBoxConverter.BOX6);
                } else {
                    appCBConverter.clear(CheckBoxConverter.BOX6);
                }
            }
        });
        appWasherCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (appWasherCheckBox.isSelected()) {
                    appCBConverter.set(CheckBoxConverter.BOX7);
                } else {
                    appCBConverter.clear(CheckBoxConverter.BOX7);
                }
            }
        });
        appRefrigeratorCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (appRefrigeratorCheckBox.isSelected()) {
                    appCBConverter.set(CheckBoxConverter.BOX8);
                } else {
                    appCBConverter.clear(CheckBoxConverter.BOX8);
                }
            }
        });
        basementConcreteFloorCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (basementConcreteFloorCheckBox.isSelected()) {
                    basementCBConverter.set(CheckBoxConverter.BOX1);
                } else {
                    basementCBConverter.clear(CheckBoxConverter.BOX1);
                }
            }
        });
        basementFinsihedCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (basementFinsihedCheckBox.isSelected()) {
                    basementCBConverter.set(CheckBoxConverter.BOX2);
                } else {
                    basementCBConverter.clear(CheckBoxConverter.BOX2);
                }
            }
        });
        basementFireplaceCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (basementFireplaceCheckBox.isSelected()) {
                    basementCBConverter.set(CheckBoxConverter.BOX3);
                } else {
                    basementCBConverter.clear(CheckBoxConverter.BOX3);
                }
            }
        });
        basementGlassBlkWindCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (basementGlassBlkWindCheckBox.isSelected()) {
                    basementCBConverter.set(CheckBoxConverter.BOX4);
                } else {
                    basementCBConverter.clear(CheckBoxConverter.BOX4);
                }
            }
        });
        basementLaminateFloorCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (basementLaminateFloorCheckBox.isSelected()) {
                    basementCBConverter.set(CheckBoxConverter.BOX5);
                } else {
                    basementCBConverter.clear(CheckBoxConverter.BOX5);
                }
            }
        });
        basementPartFinishedCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (basementPartFinishedCheckBox.isSelected()) {
                    basementCBConverter.set(CheckBoxConverter.BOX6);
                } else {
                    basementCBConverter.clear(CheckBoxConverter.BOX6);
                }
            }
        });
        basementUnfinishedCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (basementUnfinishedCheckBox.isSelected()) {
                    basementCBConverter.set(CheckBoxConverter.BOX7);
                } else {
                    basementCBConverter.clear(CheckBoxConverter.BOX7);
                }
            }
        });
        basementVinylFloorCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (basementVinylFloorCheckBox.isSelected()) {
                    basementCBConverter.set(CheckBoxConverter.BOX8);
                } else {
                    basementCBConverter.clear(CheckBoxConverter.BOX8);
                }
            }
        });
        basementWWCarpetCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (basementWWCarpetCheckBox.isSelected()) {
                    basementCBConverter.set(CheckBoxConverter.BOX9);
                } else {
                    basementCBConverter.clear(CheckBoxConverter.BOX9);
                }
            }
        });
        basementWalkoutCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (basementWalkoutCheckBox.isSelected()) {
                    basementCBConverter.set(CheckBoxConverter.BOX10);
                } else {
                    basementCBConverter.clear(CheckBoxConverter.BOX10);
                }
            }
        });
        buildingBarnCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (buildingBarnCheckBox.isSelected()) {
                    buildingCBConverter.set(CheckBoxConverter.BOX1);
                } else {
                    buildingCBConverter.clear(CheckBoxConverter.BOX1);
                }
            }
        });
        buildingGazeboCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (buildingGazeboCheckBox.isSelected()) {
                    buildingCBConverter.set(CheckBoxConverter.BOX2);
                } else {
                    buildingCBConverter.clear(CheckBoxConverter.BOX2);
                }
            }
        });
        buildingStorageCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (buildingStorageCheckBox.isSelected()) {
                    buildingCBConverter.set(CheckBoxConverter.BOX3);
                } else {
                    buildingCBConverter.clear(CheckBoxConverter.BOX3);
                }
            }
        });
        documentsSampleLeaseCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (documentsSampleLeaseCheckBox.isSelected()) {
                    documentsCBConverter.set(CheckBoxConverter.BOX1);
                } else {
                    documentsCBConverter.clear(CheckBoxConverter.BOX1);
                }
            }
        });
        documentsAerialCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (documentsAerialCheckBox.isSelected()) {
                    documentsCBConverter.set(CheckBoxConverter.BOX2);
                } else {
                    documentsCBConverter.clear(CheckBoxConverter.BOX2);
                }
            }
        });
        documentsBuildingRestricCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (documentsBuildingRestricCheckBox.isSelected()) {
                    documentsCBConverter.set(CheckBoxConverter.BOX3);
                } else {
                    documentsCBConverter.clear(CheckBoxConverter.BOX3);
                }
            }
        });
        documentsDeedRestricCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (documentsDeedRestricCheckBox.isSelected()) {
                    documentsCBConverter.set(CheckBoxConverter.BOX4);
                } else {
                    documentsCBConverter.clear(CheckBoxConverter.BOX4);
                }
            }
        });
        documentsFeasibilityCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (documentsFeasibilityCheckBox.isSelected()) {
                    documentsCBConverter.set(CheckBoxConverter.BOX5);
                } else {
                    documentsCBConverter.clear(CheckBoxConverter.BOX5);
                }
            }
        });
        documentsHOACheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (documentsHOACheckBox.isSelected()) {
                    documentsCBConverter.set(CheckBoxConverter.BOX6);
                } else {
                    documentsCBConverter.clear(CheckBoxConverter.BOX6);
                }
            }
        });
        documentsLeadPaintCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (documentsLeadPaintCheckBox.isSelected()) {
                    documentsCBConverter.set(CheckBoxConverter.BOX7);
                } else {
                    documentsCBConverter.clear(CheckBoxConverter.BOX7);
                }
            }
        });
        documentsPlanCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (documentsPlanCheckBox.isSelected()) {
                    documentsCBConverter.set(CheckBoxConverter.BOX8);
                } else {
                    documentsCBConverter.clear(CheckBoxConverter.BOX8);
                }
            }
        });
        documentsRentalAppCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (documentsRentalAppCheckBox.isSelected()) {
                    documentsCBConverter.set(CheckBoxConverter.BOX9);
                } else {
                    documentsCBConverter.clear(CheckBoxConverter.BOX9);
                }
            }
        });
        documentsSitePlanCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (documentsSitePlanCheckBox.isSelected()) {
                    documentsCBConverter.set(CheckBoxConverter.BOX10);
                } else {
                    documentsCBConverter.clear(CheckBoxConverter.BOX10);
                }
            }
        });
        documentsSoilMapCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (documentsSoilMapCheckBox.isSelected()) {
                    documentsCBConverter.set(CheckBoxConverter.BOX11);
                } else {
                    documentsCBConverter.clear(CheckBoxConverter.BOX11);
                }
            }
        });
        documentsSoilSurvCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (documentsSoilSurvCheckBox.isSelected()) {
                    documentsCBConverter.set(CheckBoxConverter.BOX12);
                } else {
                    documentsCBConverter.clear(CheckBoxConverter.BOX12);
                }
            }
        });
        documentsSurveyCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (documentsSurveyCheckBox.isSelected()) {
                    documentsCBConverter.set(CheckBoxConverter.BOX13);
                } else {
                    documentsCBConverter.clear(CheckBoxConverter.BOX13);
                }
            }
        });
        insideFeatBeamCeilingCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (insideFeatBeamCeilingCheckBox.isSelected()) {
                    insideFeatCBConverter.set(CheckBoxConverter.BOX1);
                } else {
                    insideFeatCBConverter.clear(CheckBoxConverter.BOX1);
                }
            }
        });
        insideFeatBonusRoomCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (insideFeatBonusRoomCheckBox.isSelected()) {
                    insideFeatCBConverter.set(CheckBoxConverter.BOX2);
                } else {
                    insideFeatCBConverter.clear(CheckBoxConverter.BOX2);
                }
            }
        });
        insideFeatCathCeilingCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (insideFeatCathCeilingCheckBox.isSelected()) {
                    insideFeatCBConverter.set(CheckBoxConverter.BOX3);
                } else {
                    insideFeatCBConverter.clear(CheckBoxConverter.BOX3);
                }
            }
        });
        insideFeatCrownMoldingCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (insideFeatCrownMoldingCheckBox.isSelected()) {
                    insideFeatCBConverter.set(CheckBoxConverter.BOX4);
                } else {
                    insideFeatCBConverter.clear(CheckBoxConverter.BOX4);
                }
            }
        });

        insideFeatFrechDoorCheckBox.addItemListener(
                new ItemListener() {

                    public void itemStateChanged(ItemEvent e) {
                        if (insideFeatFrechDoorCheckBox.isSelected()) {
                            insideFeatCBConverter.set(CheckBoxConverter.BOX5);
                        } else {
                            insideFeatCBConverter.clear(CheckBoxConverter.BOX5);
                        }
                    }
                });
        insideFeatGreatRoomCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (insideFeatGreatRoomCheckBox.isSelected()) {
                    insideFeatCBConverter.set(CheckBoxConverter.BOX6);
                } else {
                    insideFeatCBConverter.clear(CheckBoxConverter.BOX6);
                }
            }
        });
        insideFeatLoftCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (insideFeatLoftCheckBox.isSelected()) {
                    insideFeatCBConverter.set(CheckBoxConverter.BOX7);
                } else {
                    insideFeatCBConverter.clear(CheckBoxConverter.BOX7);
                }
            }
        });
        insideFeatMediaRoomCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (insideFeatMediaRoomCheckBox.isSelected()) {
                    insideFeatCBConverter.set(CheckBoxConverter.BOX8);
                } else {
                    insideFeatCBConverter.clear(CheckBoxConverter.BOX8);
                }
            }
        });
        insideFeatMultiPanelCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (insideFeatMultiPanelCheckBox.isSelected()) {
                    insideFeatCBConverter.set(CheckBoxConverter.BOX9);
                } else {
                    insideFeatCBConverter.clear(CheckBoxConverter.BOX9);
                }
            }
        });
        insideFeatNaturalWoodworkCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (insideFeatNaturalWoodworkCheckBox.isSelected()) {
                    insideFeatCBConverter.set(CheckBoxConverter.BOX10);
                } else {
                    insideFeatCBConverter.clear(CheckBoxConverter.BOX10);
                }
            }
        });
        insideFeatNineFootCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (insideFeatNineFootCheckBox.isSelected()) {
                    insideFeatCBConverter.set(CheckBoxConverter.BOX11);
                } else {
                    insideFeatCBConverter.clear(CheckBoxConverter.BOX11);
                }
            }
        });
        insideFeatRecessCeilingCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (insideFeatRecessCeilingCheckBox.isSelected()) {
                    insideFeatCBConverter.set(CheckBoxConverter.BOX12);
                } else {
                    insideFeatCBConverter.clear(CheckBoxConverter.BOX12);
                }
            }
        });
        insideFeatSolariumCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (insideFeatSolariumCheckBox.isSelected()) {
                    insideFeatCBConverter.set(CheckBoxConverter.BOX13);
                } else {
                    insideFeatCBConverter.clear(CheckBoxConverter.BOX13);
                }
            }
        });
        insideFeatVaultCeilingCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (insideFeatVaultCeilingCheckBox.isSelected()) {
                    insideFeatCBConverter.set(CheckBoxConverter.BOX14);
                } else {
                    insideFeatCBConverter.clear(CheckBoxConverter.BOX14);
                }
            }
        });
        miscAirCleanerCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (miscAirCleanerCheckBox.isSelected()) {
                    miscCBConverter.set(CheckBoxConverter.BOX1);
                } else {
                    miscCBConverter.clear(CheckBoxConverter.BOX1);
                }
            }
        });
        miscCableTvCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (miscCableTvCheckBox.isSelected()) {
                    miscCBConverter.set(CheckBoxConverter.BOX2);
                } else {
                    miscCBConverter.clear(CheckBoxConverter.BOX2);
                }
            }
        });
        miscCeilingFanCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (miscCeilingFanCheckBox.isSelected()) {
                    miscCBConverter.set(CheckBoxConverter.BOX3);
                } else {
                    miscCBConverter.clear(CheckBoxConverter.BOX3);
                }
            }
        });
        miscCoinLaundryCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (miscCoinLaundryCheckBox.isSelected()) {
                    miscCBConverter.set(CheckBoxConverter.BOX4);
                } else {
                    miscCBConverter.clear(CheckBoxConverter.BOX4);
                }
            }
        });
        miscDehumidifierCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (miscDehumidifierCheckBox.isSelected()) {
                    miscCBConverter.set(CheckBoxConverter.BOX5);
                } else {
                    miscCBConverter.clear(CheckBoxConverter.BOX5);
                }
            }
        });
        miscFountainCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (miscFountainCheckBox.isSelected()) {
                    miscCBConverter.set(CheckBoxConverter.BOX6);
                } else {
                    miscCBConverter.clear(CheckBoxConverter.BOX6);
                }
            }
        });
        miscGarageDoorOpenerCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (miscGarageDoorOpenerCheckBox.isSelected()) {
                    miscCBConverter.set(CheckBoxConverter.BOX7);
                } else {
                    miscCBConverter.clear(CheckBoxConverter.BOX7);
                }
            }
        });
        miscHighTextWiringCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (miscHighTextWiringCheckBox.isSelected()) {
                    miscCBConverter.set(CheckBoxConverter.BOX8);
                } else {
                    miscCBConverter.clear(CheckBoxConverter.BOX8);
                }
            }
        });
        miscRecessLightCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (miscRecessLightCheckBox.isSelected()) {
                    miscCBConverter.set(CheckBoxConverter.BOX9);
                } else {
                    miscCBConverter.clear(CheckBoxConverter.BOX9);
                }
            }
        });
        miscSmokeAlarmCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (miscSmokeAlarmCheckBox.isSelected()) {
                    miscCBConverter.set(CheckBoxConverter.BOX10);
                } else {
                    miscCBConverter.clear(CheckBoxConverter.BOX10);
                }
            }
        });
        miscSumpPumpCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (miscSumpPumpCheckBox.isSelected()) {
                    miscCBConverter.set(CheckBoxConverter.BOX11);
                } else {
                    miscCBConverter.clear(CheckBoxConverter.BOX11);
                }
            }
        });
        miscWaterSoftenerCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (miscWaterSoftenerCheckBox.isSelected()) {
                    miscCBConverter.set(CheckBoxConverter.BOX12);
                } else {
                    miscCBConverter.clear(CheckBoxConverter.BOX12);
                }
            }
        });
        outsideFeatBalconyCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatBalconyCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX1);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX1);
                }
            }
        });
        outsideFeatCornerLotCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatCornerLotCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX2);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX2);
                }
            }
        });
        outsideFeatCoveredDeckCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatCoveredDeckCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX3);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX3);
                }
            }
        });
        outsideFeatCulDeSacCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatCulDeSacCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX4);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX4);
                }
            }
        });
        outsideFeatDeckCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatDeckCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX5);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX5);
                }
            }
        });
        outsideFeatEnclPorchCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatEnclPorchCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX6);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX6);
                }
            }
        });
        outsideFeatFlagLotCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatFlagLotCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX7);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX7);
                }
            }
        });
        outsideFeatHotTubCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatHotTubCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX8);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX8);
                }
            }
        });
        outsideFeatInvisibleFenceCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatInvisibleFenceCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX9);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX9);
                }
            }
        });
        outsideFeatMetalFenceCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatMetalFenceCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX10);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX10);
                }
            }
        });
        outsideFeatPatioCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatPatioCheckBox.isSelected()) {

                    outsideFeatCBConverter.set(CheckBoxConverter.BOX11);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX11);
                }
            }
        });
        outsideFeatPoolAboveCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatPoolAboveCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX12);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX12);
                }
            }
        });
        outsideFeatPoolIngroundCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatPoolIngroundCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX13);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX13);
                }
            }
        });
        outsideFeatPorchCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatPorchCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX14);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX14);
                }
            }
        });
        outsideFeatPrivacyFenceCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatPrivacyFenceCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX15);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX15);
                }
            }
        });
        outsideFeatSprinklersCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatSprinklersCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX16);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX16);
                }
            }
        });
        outsideFeatTennisCourtCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatTennisCourtCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX17);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX17);
                }
            }
        });
        outsideFeatTieredDeckCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatBalconyCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX18);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX18);
                }
            }
        });
        outsideFeatVinylFenceCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatVinylFenceCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX19);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX19);
                }
            }
        });
        outsideFeatWoodFenceCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatWoodFenceCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX20);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX20);
                }
            }
        });
        outsideFeatWoodedLotCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatWoodedLotCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX21);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX21);
                }
            }
        });
        outsideFeatYardLightsCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (outsideFeatYardLightsCheckBox.isSelected()) {
                    outsideFeatCBConverter.set(CheckBoxConverter.BOX22);
                } else {
                    outsideFeatCBConverter.clear(CheckBoxConverter.BOX22);
                }
            }
        });
        viewCityCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (viewCityCheckBox.isSelected()) {
                    viewCBConverter.set(CheckBoxConverter.BOX1);
                } else {
                    viewCBConverter.clear(CheckBoxConverter.BOX1);
                }
            }
        });
        viewLakeCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (viewLakeCheckBox.isSelected()) {
                    viewCBConverter.set(CheckBoxConverter.BOX2);
                } else {
                    viewCBConverter.clear(CheckBoxConverter.BOX2);
                }
            }
        });
        viewParkCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (viewParkCheckBox.isSelected()) {
                    viewCBConverter.set(CheckBoxConverter.BOX3);
                } else {
                    viewCBConverter.clear(CheckBoxConverter.BOX3);
                }
            }
        });
        viewRiverCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (viewRiverCheckBox.isSelected()) {
                    viewCBConverter.set(CheckBoxConverter.BOX4);
                } else {
                    viewCBConverter.clear(CheckBoxConverter.BOX4);
                }
            }
        });
        viewWoodsCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (viewWoodsCheckBox.isSelected()) {
                    viewCBConverter.set(CheckBoxConverter.BOX5);
                } else {
                    viewCBConverter.clear(CheckBoxConverter.BOX5);
                }
            }
        });
        zoningBusinessCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (zoningBusinessCheckBox.isSelected()) {
                    zoningCBConverter.set(CheckBoxConverter.BOX1);
                } else {
                    zoningCBConverter.clear(CheckBoxConverter.BOX1);
                }
            }
        });
        zoningCommercialCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (zoningCommercialCheckBox.isSelected()) {
                    zoningCBConverter.set(CheckBoxConverter.BOX2);
                } else {
                    zoningCBConverter.clear(CheckBoxConverter.BOX2);
                }
            }
        });
        zoningIndustrialCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (zoningIndustrialCheckBox.isSelected()) {
                    zoningCBConverter.set(CheckBoxConverter.BOX3);
                } else {
                    zoningCBConverter.clear(CheckBoxConverter.BOX3);
                }
            }
        });
        zoningMobileHomeCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (zoningMobileHomeCheckBox.isSelected()) {
                    zoningCBConverter.set(CheckBoxConverter.BOX4);
                } else {
                    zoningCBConverter.clear(CheckBoxConverter.BOX4);
                }
            }
        });
        zoningMultiFamilyCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (zoningMultiFamilyCheckBox.isSelected()) {
                    zoningCBConverter.set(CheckBoxConverter.BOX5);
                } else {
                    zoningCBConverter.clear(CheckBoxConverter.BOX5);
                }
            }
        });
        zoningNonconformingCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (zoningNonconformingCheckBox.isSelected()) {
                    zoningCBConverter.set(CheckBoxConverter.BOX6);
                } else {
                    zoningCBConverter.clear(CheckBoxConverter.BOX6);
                }
            }
        });
        zoningOfficeCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (zoningOfficeCheckBox.isSelected()) {
                    zoningCBConverter.set(CheckBoxConverter.BOX7);
                } else {
                    zoningCBConverter.clear(CheckBoxConverter.BOX7);
                }
            }
        });
        zoningResidentialCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (zoningResidentialCheckBox.isSelected()) {
                    zoningCBConverter.set(CheckBoxConverter.BOX8);
                } else {
                    zoningCBConverter.clear(CheckBoxConverter.BOX8);
                }
            }
        });
        zoningUnzonedCheckBox.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {
                if (zoningUnzonedCheckBox.isSelected()) {
                    zoningCBConverter.set(CheckBoxConverter.BOX9);
                } else {
                    zoningCBConverter.clear(CheckBoxConverter.BOX9);
                }
            }
        });
    }

    public PropertyFeaturesPanel(DAO daoObject, Property prop, boolean oldProp) {
        this(daoObject, prop);
        setAmenitiesPanel();
        setAppliancePanel();
        setBuildingPanel();
        setBasementPanel();
        setMiscPanel();
        setInsidePanel();
        setOutsidePanel();
        setZoningPanel();
        setDocumentsPanel();
        setViewPanel();
    }

    private void createFeaturesPanel() {
        this.setLayout(new BorderLayout());
        this.setPreferredSize(new Dimension(100, 200));
        this.add(new JLabel("Property Features", SwingConstants.CENTER), BorderLayout.NORTH);
        this.add(topLeft, BorderLayout.WEST);
        this.add(topRight, BorderLayout.CENTER);

    }

    private void createBasementPanel() {
        basementPanel.setLayout(new GridLayout(4, 3));
        basementPanel.add(basementConcreteFloorCheckBox);
        basementPanel.add(basementFinsihedCheckBox);
        basementPanel.add(basementFireplaceCheckBox);
        basementPanel.add(basementGlassBlkWindCheckBox);
        basementPanel.add(basementLaminateFloorCheckBox);
        basementPanel.add(basementPartFinishedCheckBox);
        basementPanel.add(basementUnfinishedCheckBox);
        basementPanel.add(basementVinylFloorCheckBox);
        basementPanel.add(basementWWCarpetCheckBox);
        basementPanel.add(basementWalkoutCheckBox);
    }

    private void setBasementPanel() {
        for (int i = 1; i < basementCBConverter.getMax() - 1; i++) {
            if (basementCBConverter.checkOn(i)) {
                switch (i) {
                    case 1: {
                        basementConcreteFloorCheckBox.setEnabled(true);
                        break;
                    }
                    case 2: {
                        basementFinsihedCheckBox.setEnabled(true);
                        break;
                    }
                    case 3: {
                        basementFireplaceCheckBox.setEnabled(true);
                        break;
                    }
                    case 4: {
                        basementGlassBlkWindCheckBox.setEnabled(true);
                        break;
                    }
                    case 5: {
                        basementLaminateFloorCheckBox.setEnabled(true);
                        break;
                    }
                    case 6: {
                        basementPartFinishedCheckBox.setEnabled(true);
                        break;
                    }
                    case 7: {
                        basementUnfinishedCheckBox.setEnabled(true);
                        break;
                    }
                    case 8: {
                        basementVinylFloorCheckBox.setEnabled(true);
                        break;
                    }
                    case 9: {
                        basementWWCarpetCheckBox.setEnabled(true);
                        break;
                    }
                    case 10: {
                        basementWalkoutCheckBox.setEnabled(true);
                        break;
                    }
                }
            }
        }
    }

    private void createInsideFeaturesPanel() {
        insideFeaturesPanel.setLayout(new GridLayout(5, 3));
        insideFeaturesPanel.add(insideFeatBeamCeilingCheckBox);
        insideFeaturesPanel.add(insideFeatBonusRoomCheckBox);
        insideFeaturesPanel.add(insideFeatCathCeilingCheckBox);
        insideFeaturesPanel.add(insideFeatCrownMoldingCheckBox);
        insideFeaturesPanel.add(insideFeatFrechDoorCheckBox);
        insideFeaturesPanel.add(insideFeatGreatRoomCheckBox);
        insideFeaturesPanel.add(insideFeatLoftCheckBox);
        insideFeaturesPanel.add(insideFeatMediaRoomCheckBox);
        insideFeaturesPanel.add(insideFeatMultiPanelCheckBox);
        insideFeaturesPanel.add(insideFeatNaturalWoodworkCheckBox);
        insideFeaturesPanel.add(insideFeatNineFootCheckBox);
        insideFeaturesPanel.add(insideFeatRecessCeilingCheckBox);
        insideFeaturesPanel.add(insideFeatSolariumCheckBox);
        insideFeaturesPanel.add(insideFeatVaultCeilingCheckBox);
    }

    private void setInsidePanel() {
        for (int i = 1; i < insideFeatCBConverter.getMax() - 1; i++) {
            if (insideFeatCBConverter.checkOn(i)) {
                switch (i) {
                    case 1: {
                        insideFeatBeamCeilingCheckBox.setEnabled(true);
                        break;
                    }
                    case 2: {
                        insideFeatBonusRoomCheckBox.setEnabled(true);
                        break;
                    }
                    case 3: {
                        insideFeatCathCeilingCheckBox.setEnabled(true);
                        break;
                    }
                    case 4: {
                        insideFeatCrownMoldingCheckBox.setEnabled(true);
                        break;
                    }
                    case 5: {
                        insideFeatFrechDoorCheckBox.setEnabled(true);
                        break;
                    }
                    case 6: {
                        insideFeatGreatRoomCheckBox.setEnabled(true);
                        break;
                    }
                    case 7: {
                        insideFeatLoftCheckBox.setEnabled(true);
                        break;
                    }
                    case 8: {
                        insideFeatMediaRoomCheckBox.setEnabled(true);
                        break;
                    }
                    case 9: {
                        insideFeatMultiPanelCheckBox.setEnabled(true);
                        break;
                    }
                    case 10: {
                        insideFeatNaturalWoodworkCheckBox.setEnabled(true);
                        break;
                    }
                    case 11: {
                        insideFeatNineFootCheckBox.setEnabled(true);
                        break;
                    }
                    case 12: {
                        insideFeatRecessCeilingCheckBox.setEnabled(true);
                        break;
                    }
                    case 13: {
                        insideFeatSolariumCheckBox.setEnabled(true);
                        break;
                    }
                    case 14: {
                        insideFeatVaultCeilingCheckBox.setEnabled(true);
                        break;
                    }
                }
            }
        }
    }

    private void createOutsidePanel() {
        outsideFeaturesPanel.setLayout(new BorderLayout());
        JPanel outsideFeaturesPanel2 = new JPanel();
        outsideFeaturesPanel2.setLayout(new GridLayout(8, 3));
        outsideFeaturesPanel2.add(outsideFeatBalconyCheckBox);
        outsideFeaturesPanel2.add(outsideFeatCornerLotCheckBox);
        outsideFeaturesPanel2.add(outsideFeatCoveredDeckCheckBox);
        outsideFeaturesPanel2.add(outsideFeatCulDeSacCheckBox);
        outsideFeaturesPanel2.add(outsideFeatDeckCheckBox);
        outsideFeaturesPanel2.add(outsideFeatEnclPorchCheckBox);
        outsideFeaturesPanel2.add(outsideFeatFlagLotCheckBox);
        outsideFeaturesPanel2.add(outsideFeatHotTubCheckBox);
        outsideFeaturesPanel2.add(outsideFeatInvisibleFenceCheckBox);
        outsideFeaturesPanel2.add(outsideFeatMetalFenceCheckBox);
        outsideFeaturesPanel2.add(outsideFeatPatioCheckBox);
        outsideFeaturesPanel2.add(outsideFeatPoolAboveCheckBox);
        outsideFeaturesPanel2.add(outsideFeatPoolIngroundCheckBox);
        outsideFeaturesPanel2.add(outsideFeatPorchCheckBox);
        outsideFeaturesPanel2.add(outsideFeatPrivacyFenceCheckBox);
        outsideFeaturesPanel2.add(outsideFeatSprinklersCheckBox);
        outsideFeaturesPanel2.add(outsideFeatTennisCourtCheckBox);
        outsideFeaturesPanel2.add(outsideFeatTieredDeckCheckBox);
        outsideFeaturesPanel2.add(outsideFeatVinylFenceCheckBox);
        outsideFeaturesPanel2.add(outsideFeatWoodFenceCheckBox);
        outsideFeaturesPanel2.add(outsideFeatWoodedLotCheckBox);
        outsideFeaturesPanel2.add(outsideFeatYardLightsCheckBox);
        outsideFeaturesPanel.add(outsideFeaturesPanel2, BorderLayout.CENTER);
    }

    private void setOutsidePanel() {
        for (int i = 1; i < outsideFeatCBConverter.getMax() - 1; i++) {
            if (outsideFeatCBConverter.checkOn(i)) {
                switch (i) {
                    case 1: {
                        outsideFeatBalconyCheckBox.setEnabled(true);
                        break;
                    }
                    case 2: {
                        outsideFeatCornerLotCheckBox.setEnabled(true);
                        break;
                    }
                    case 3: {
                        outsideFeatCoveredDeckCheckBox.setEnabled(true);
                        break;
                    }
                    case 4: {
                        outsideFeatCulDeSacCheckBox.setEnabled(true);
                        break;
                    }
                    case 5: {
                        outsideFeatDeckCheckBox.setEnabled(true);
                        break;
                    }
                    case 6: {
                        outsideFeatEnclPorchCheckBox.setEnabled(true);
                        break;
                    }
                    case 7: {
                        outsideFeatFlagLotCheckBox.setEnabled(true);
                        break;
                    }
                    case 8: {
                        outsideFeatHotTubCheckBox.setEnabled(true);
                        break;
                    }
                    case 9: {
                        outsideFeatInvisibleFenceCheckBox.setEnabled(true);
                        break;
                    }
                    case 10: {
                        outsideFeatMetalFenceCheckBox.setEnabled(true);
                        break;
                    }
                    case 11: {
                        outsideFeatPatioCheckBox.setEnabled(true);
                        break;
                    }
                    case 12: {
                        outsideFeatPoolAboveCheckBox.setEnabled(true);
                        break;
                    }
                    case 13: {
                        outsideFeatPoolIngroundCheckBox.setEnabled(true);
                        break;
                    }
                    case 14: {
                        outsideFeatPorchCheckBox.setEnabled(true);
                        break;
                    }
                    case 15: {
                        outsideFeatPrivacyFenceCheckBox.setEnabled(true);
                        break;
                    }
                    case 16: {
                        outsideFeatSprinklersCheckBox.setEnabled(true);
                        break;
                    }
                    case 17: {
                        outsideFeatTennisCourtCheckBox.setEnabled(true);
                        break;
                    }
                    case 18: {
                        outsideFeatTieredDeckCheckBox.setEnabled(true);
                        break;
                    }
                    case 19: {
                        outsideFeatVinylFenceCheckBox.setEnabled(true);
                        break;
                    }
                    case 20: {
                        outsideFeatWoodFenceCheckBox.setEnabled(true);
                        break;
                    }
                    case 21: {
                        outsideFeatWoodedLotCheckBox.setEnabled(true);
                        break;
                    }
                    case 22: {
                        outsideFeatYardLightsCheckBox.setEnabled(true);
                        break;
                    }
                }
            }
        }
    }

    private void createMiscPanel() {
        miscPanel.setLayout(new BorderLayout());
        JPanel miscPanel2 = new JPanel(new GridLayout(4, 3));
        miscPanel2.add(miscAirCleanerCheckBox);
        miscPanel2.add(miscCableTvCheckBox);
        miscPanel2.add(miscCeilingFanCheckBox);
        miscPanel2.add(miscCoinLaundryCheckBox);
        miscPanel2.add(miscDehumidifierCheckBox);
        miscPanel2.add(miscFountainCheckBox);
        miscPanel2.add(miscGarageDoorOpenerCheckBox);
        miscPanel2.add(miscHighTextWiringCheckBox);
        miscPanel2.add(miscRecessLightCheckBox);
        miscPanel2.add(miscSmokeAlarmCheckBox);
        miscPanel2.add(miscSumpPumpCheckBox);
        miscPanel2.add(miscWaterSoftenerCheckBox);
        miscPanel.add(miscPanel2, BorderLayout.CENTER);
    }

    private void setMiscPanel() {
        for (int i = 1; i < miscCBConverter.getMax() - 1; i++) {
            if (miscCBConverter.checkOn(i)) {
                switch (i) {
                    case 1: {
                        miscAirCleanerCheckBox.setEnabled(true);
                        break;
                    }
                    case 2: {
                        miscCableTvCheckBox.setEnabled(true);
                        break;
                    }
                    case 3: {
                        miscCeilingFanCheckBox.setEnabled(true);
                        break;
                    }
                    case 4: {
                        miscCoinLaundryCheckBox.setEnabled(true);
                        break;
                    }
                    case 5: {
                        miscDehumidifierCheckBox.setEnabled(true);
                        break;
                    }
                    case 6: {
                        miscFountainCheckBox.setEnabled(true);
                        break;
                    }
                    case 7: {
                        miscGarageDoorOpenerCheckBox.setEnabled(true);
                        break;
                    }
                    case 8: {
                        miscHighTextWiringCheckBox.setEnabled(true);
                        break;
                    }
                    case 9: {
                        miscRecessLightCheckBox.setEnabled(true);
                        break;
                    }
                    case 10: {
                        miscSmokeAlarmCheckBox.setEnabled(true);
                        break;
                    }
                    case 11: {
                        miscSumpPumpCheckBox.setEnabled(true);
                        break;
                    }
                    case 12: {
                        miscSumpPumpCheckBox.setEnabled(true);
                        break;
                    }
                }
            }
        }
    }

    private void createViewPanel() {
        viewPanel.setLayout(new GridLayout(6, 1));
        viewPanel.add(viewCityCheckBox);
        viewPanel.add(viewLakeCheckBox);
        viewPanel.add(viewParkCheckBox);
        viewPanel.add(viewRiverCheckBox);
        viewPanel.add(viewWoodsCheckBox);

    }

    private void setViewPanel() {
        for (int i = 1; i < viewCBConverter.getMax() - 1; i++) {
            if (viewCBConverter.checkOn(i)) {
                switch (i) {
                    case 1: {
                        viewCityCheckBox.setEnabled(true);
                        break;
                    }
                    case 2: {
                        viewLakeCheckBox.setEnabled(true);
                        break;
                    }
                    case 3: {
                        viewParkCheckBox.setEnabled(true);
                        break;
                    }
                    case 4: {
                        viewRiverCheckBox.setEnabled(true);
                        break;
                    }
                    case 5: {
                        viewWoodsCheckBox.setEnabled(true);
                        break;
                    }
                }
            }
        }
    }

    private void createAppliancePanel() {
        appliancePanel.setLayout(new GridLayout(4, 2));
        appliancePanel.add(appCompactorCheckBox);
        appliancePanel.add(appDishWasherCheckBox);
        appliancePanel.add(appDryerCheckBox);
        appliancePanel.add(appGarbageDishCheckBox);
        appliancePanel.add(appMicrowaveCheckBox);
        appliancePanel.add(appOvenCheckBox);
        appliancePanel.add(appRefrigeratorCheckBox);
        appliancePanel.add(appWasherCheckBox);
    }

    private void setAppliancePanel() {
        for (int i = 1; i < appCBConverter.getMax() - 1; i++) {
            if (appCBConverter.checkOn(i)) {
                switch (i) {
                    case 1: {
                        appCompactorCheckBox.setEnabled(true);
                        break;
                    }
                    case 2: {
                        appDishWasherCheckBox.setEnabled(true);
                        break;
                    }
                    case 3: {
                        appDryerCheckBox.setEnabled(true);
                        break;
                    }
                    case 4: {
                        appGarbageDishCheckBox.setEnabled(true);
                        break;
                    }
                    case 5: {
                        appMicrowaveCheckBox.setEnabled(true);
                        break;
                    }
                    case 6: {
                        appOvenCheckBox.setEnabled(true);
                        break;
                    }
                    case 7: {
                        appRefrigeratorCheckBox.setEnabled(true);
                        break;
                    }
                    case 8: {
                        appWasherCheckBox.setEnabled(true);
                        break;
                    }
                }
            }
        }
    }

    private void createBuildingPanel() {
        buildingPanel.setLayout(new GridLayout(4, 1));
        buildingPanel.add(buildingBarnCheckBox);
        buildingPanel.add(buildingGazeboCheckBox);
        buildingPanel.add(buildingStorageCheckBox);
    }

    private void setBuildingPanel() {
        for (int i = 1; i < buildingCBConverter.getMax() - 1; i++) {
            if (buildingCBConverter.checkOn(i)) {
                switch (i) {
                    case 1: {
                        buildingBarnCheckBox.setEnabled(true);
                        break;
                    }
                    case 2: {
                        buildingGazeboCheckBox.setEnabled(true);
                        break;
                    }
                    case 3: {
                        buildingStorageCheckBox.setEnabled(true);
                        break;
                    }
                }
            }
        }
    }

    private void createAmenitiesPanel() {
        amenitiesPanel.setLayout(new GridLayout(4, 2));
        amenitiesPanel.add(amenitiesElectricCheckBox);
        amenitiesPanel.add(amenitiesGasCheckBox);
        amenitiesPanel.add(amenitiesHeatCheckBox);
        amenitiesPanel.add(amenitiesLandscapingCheckBox);
        amenitiesPanel.add(amenitiesMaintenanceCheckBox);
        amenitiesPanel.add(amenitiesPoolCheckBox);
        amenitiesPanel.add(amenitiesTrashCheckBox);
        amenitiesPanel.add(amenitiesWaterCheckBox);
    }

    private void setAmenitiesPanel() {
        for (int i = 1; i < amenitiesCBConverter.getMax() - 1; i++) {
            if (amenitiesCBConverter.checkOn(i)) {
                switch (i) {
                    case 1: {
                        amenitiesElectricCheckBox.setEnabled(true);
                        break;
                    }
                    case 2: {
                        amenitiesGasCheckBox.setEnabled(true);
                        break;
                    }
                    case 3: {
                        amenitiesHeatCheckBox.setEnabled(true);
                        break;
                    }
                    case 4: {
                        amenitiesLandscapingCheckBox.setEnabled(true);
                        break;
                    }
                    case 5: {
                        amenitiesMaintenanceCheckBox.setEnabled(true);
                        break;
                    }
                    case 6: {
                        amenitiesPlayAreaCheckBox.setEnabled(true);
                        break;
                    }
                    case 7: {
                        amenitiesPoolCheckBox.setEnabled(true);
                        break;
                    }
                    case 8: {
                        amenitiesSecurityAlarmCheckBox.setEnabled(true);
                        break;
                    }
                    case 9: {
                        amenitiesTrashCheckBox.setEnabled(true);
                        break;
                    }
                    case 10: {
                        amenitiesTrashCheckBox.setEnabled(true);
                        break;
                    }
                }
            }
        }
    }

    private void createDocumentsPanel() {
        documentsPanel.setLayout(new GridLayout(5, 3));
        documentsPanel.add(documentsAerialCheckBox);
        documentsPanel.add(documentsBuildingRestricCheckBox);
        documentsPanel.add(documentsDeedRestricCheckBox);
        documentsPanel.add(documentsDeedRestricCheckBox);
        documentsPanel.add(documentsFeasibilityCheckBox);
        documentsPanel.add(documentsHOACheckBox);
        documentsPanel.add(documentsLeadPaintCheckBox);
        documentsPanel.add(documentsPlanCheckBox);
        documentsPanel.add(documentsRentalAppCheckBox);
        documentsPanel.add(documentsSitePlanCheckBox);
        documentsPanel.add(documentsSoilMapCheckBox);
        documentsPanel.add(documentsSoilSurvCheckBox);
        documentsPanel.add(documentsSurveyCheckBox);
    }

    private void setDocumentsPanel() {
        for (int i = 1; i < documentsCBConverter.getMax() - 1; i++) {
            if (documentsCBConverter.checkOn(i)) {
                switch (i) {
                    case 1: {
                        documentsAerialCheckBox.setEnabled(true);
                        break;
                    }
                    case 2: {
                        documentsBuildingRestricCheckBox.setEnabled(true);
                        break;
                    }
                    case 3: {
                        documentsDeedRestricCheckBox.setEnabled(true);
                        break;
                    }
                    case 4: {
                        documentsFeasibilityCheckBox.setEnabled(true);
                        break;
                    }
                    case 5: {
                        documentsHOACheckBox.setEnabled(true);
                        break;
                    }
                    case 6: {
                        documentsLeadPaintCheckBox.setEnabled(true);
                        break;
                    }
                    case 7: {
                        documentsPlanCheckBox.setEnabled(true);
                        break;
                    }
                    case 8: {
                        documentsRentalAppCheckBox.setEnabled(true);
                        break;
                    }
                    case 9: {
                        documentsSampleLeaseCheckBox.setEnabled(true);
                        break;
                    }
                    case 10: {
                        documentsSitePlanCheckBox.setEnabled(true);
                        break;
                    }
                    case 11: {
                        documentsSoilMapCheckBox.setEnabled(true);
                        break;
                    }
                    case 12: {
                        documentsSoilSurvCheckBox.setEnabled(true);
                        break;
                    }
                    case 13: {
                        documentsSurveyCheckBox.setEnabled(true);
                        break;
                    }
                }
            }
        }
    }

    private void createZoningPanel() {
        zoningPanel.setLayout(new BorderLayout());
        JPanel zoningPanel2 = new JPanel(new GridLayout(3, 3));
        zoningPanel2.add(zoningBusinessCheckBox);
        zoningPanel2.add(zoningCommercialCheckBox);
        zoningPanel2.add(zoningIndustrialCheckBox);
        zoningPanel2.add(zoningMobileHomeCheckBox);
        zoningPanel2.add(zoningMultiFamilyCheckBox);
        zoningPanel2.add(zoningNonconformingCheckBox);
        zoningPanel2.add(zoningOfficeCheckBox);
        zoningPanel2.add(zoningResidentialCheckBox);
        zoningPanel2.add(zoningUnzonedCheckBox);
        zoningPanel.add(zoningPanel2, BorderLayout.CENTER);
    }

    private void setZoningPanel() {
        for (int i = 1; i < zoningCBConverter.getMax() - 1; i++) {
            if (zoningCBConverter.checkOn(i)) {
                switch (i) {
                    case 1: {
                        zoningBusinessCheckBox.setEnabled(true);
                        break;
                    }
                    case 2: {
                        zoningCommercialCheckBox.setEnabled(true);
                        break;
                    }
                    case 3: {
                        zoningIndustrialCheckBox.setEnabled(true);
                        break;
                    }
                    case 4: {
                        zoningMobileHomeCheckBox.setEnabled(true);
                        break;
                    }
                    case 5: {
                        zoningMultiFamilyCheckBox.setEnabled(true);
                        break;
                    }
                    case 6: {
                        zoningNonconformingCheckBox.setEnabled(true);
                        break;
                    }
                    case 7: {
                        zoningOfficeCheckBox.setEnabled(true);
                        break;
                    }
                    case 8: {
                        zoningResidentialCheckBox.setEnabled(true);
                        break;
                    }
                    case 9: {
                        zoningUnzonedCheckBox.setEnabled(true);
                        break;
                    }

                }
            }
        }
    }

    /**
     * @return the value of amenitiesCBConverter
     */
    public int getAmenitiesCBConverter() {
        return amenitiesCBConverter.getValue();
    }

    /**
     * @return the value of appCBConverter
     */
    public int getAppCBConverter() {
        return appCBConverter.getValue();
    }

    /**
     * @return the value of basementCBConverter
     */
    public int getBasementCBConverter() {
        return basementCBConverter.getValue();
    }

    /**
     * @return the value of buildingCBConverter
     */
    public int getBuildingCBConverter() {
        return buildingCBConverter.getValue();
    }

    /**
     * @return the value of documentsCBConverter
     */
    public int getDocumentsCBConverter() {
        return documentsCBConverter.getValue();
    }

    /**
     * @return the value of insideFeatCBConverter
     */
    public int getInsideFeatCBConverter() {
        return insideFeatCBConverter.getValue();
    }

    /**
     * @return the value of miscCBConverter
     */
    public int getMiscCBConverter() {
        return miscCBConverter.getValue();
    }

    /**
     * @return the value of outsideFeatCBConverter
     */
    public int getOutsideFeatCBConverter() {
        return outsideFeatCBConverter.getValue();
    }

    /**
     * @return the value of viewCBConverter
     */
    public int getViewCBConverter() {
        return viewCBConverter.getValue();
    }

    /**
     * @return the value of zoningCBConverter
     */
    public int getZoningCBConverter() {
        return zoningCBConverter.getValue();
    }

    private void initComponents() {

        amenitiesCBConverter = new CheckBoxConverter(10);
        appCBConverter = new CheckBoxConverter(8);
        basementCBConverter = new CheckBoxConverter(10);
        buildingCBConverter = new CheckBoxConverter(3);
        documentsCBConverter = new CheckBoxConverter(13);
        insideFeatCBConverter = new CheckBoxConverter(14);
        miscCBConverter = new CheckBoxConverter(12);
        outsideFeatCBConverter = new CheckBoxConverter(22);
        viewCBConverter = new CheckBoxConverter(5);
        zoningCBConverter = new CheckBoxConverter(9);
        zoningPanel = new JPanel();
        amenitiesElectricCheckBox = new JCheckBox("Electric");
        amenitiesGasCheckBox = new JCheckBox("Gas");
        amenitiesHeatCheckBox = new JCheckBox("Heat");
        amenitiesLandscapingCheckBox = new JCheckBox("Landscaping");
        amenitiesMaintenanceCheckBox = new JCheckBox("Maintenance");
        amenitiesPlayAreaCheckBox = new JCheckBox("Play Area");
        amenitiesPoolCheckBox = new JCheckBox("Pool");
        amenitiesSecurityAlarmCheckBox = new JCheckBox("Security Alarm");
        amenitiesTrashCheckBox = new JCheckBox("Trash");
        amenitiesWaterCheckBox = new JCheckBox("Water");
        appCompactorCheckBox = new JCheckBox("Compactor");
        appDishWasherCheckBox = new JCheckBox("Dishwasher");
        appDryerCheckBox = new JCheckBox("Dryer");
        appGarbageDishCheckBox = new JCheckBox("Garbage Disposal");
        appMicrowaveCheckBox = new JCheckBox("Microwave");
        appOvenCheckBox = new JCheckBox("Oven/Range");
        appRefrigeratorCheckBox = new JCheckBox("Refrigerator");
        appWasherCheckBox = new JCheckBox("Washer");
        basementConcreteFloorCheckBox = new JCheckBox("Concrete Floor");
        basementFinsihedCheckBox = new JCheckBox("Finsihed");
        basementFireplaceCheckBox = new JCheckBox("Fireplace");
        basementGlassBlkWindCheckBox = new JCheckBox("Glass Blk Wind");
        basementLaminateFloorCheckBox = new JCheckBox("Laminate Floor");
        basementPartFinishedCheckBox = new JCheckBox("Partial");
        basementUnfinishedCheckBox = new JCheckBox("Unfinished");
        basementVinylFloorCheckBox = new JCheckBox("Vinyl Floor");
        basementWalkoutCheckBox = new JCheckBox("Walkout");
        basementWWCarpetCheckBox = new JCheckBox("WW Carpet");
        buildingBarnCheckBox = new JCheckBox("Barn");
        buildingGazeboCheckBox = new JCheckBox("Gazebo");
        buildingStorageCheckBox = new JCheckBox("Storage Shed");
        documentsAerialCheckBox = new JCheckBox("Aerial Photos");
        documentsBuildingRestricCheckBox = new JCheckBox("Building Restric");
        documentsDeedRestricCheckBox = new JCheckBox("Deed Restric");
        documentsFeasibilityCheckBox = new JCheckBox("Feasibility");
        documentsHOACheckBox = new JCheckBox("HOA By-Laws");
        documentsLeadPaintCheckBox = new JCheckBox("Lead Paint Disc");
        documentsPlanCheckBox = new JCheckBox("Plan/Plat");
        documentsRentalAppCheckBox = new JCheckBox("Rental App");
        documentsSampleLeaseCheckBox = new JCheckBox("Sample Lease");
        documentsSitePlanCheckBox = new JCheckBox("Site Plan");
        documentsSoilMapCheckBox = new JCheckBox("Soil Map");
        documentsSoilSurvCheckBox = new JCheckBox("Soil Survey");
        documentsSurveyCheckBox = new JCheckBox("Survey");
        insideFeatBeamCeilingCheckBox = new JCheckBox("Beam Ceiling");
        insideFeatBonusRoomCheckBox = new JCheckBox("Bonus Room");
        insideFeatCathCeilingCheckBox = new JCheckBox("Cathedral Ceiling");
        insideFeatCrownMoldingCheckBox = new JCheckBox("Crown Molding");
        insideFeatFrechDoorCheckBox = new JCheckBox("French Doors");
        insideFeatGreatRoomCheckBox = new JCheckBox("Great Room");
        insideFeatLoftCheckBox = new JCheckBox("Loft");
        insideFeatMediaRoomCheckBox = new JCheckBox("Media Room");
        insideFeatMultiPanelCheckBox = new JCheckBox("Multi Panel Doors");
        insideFeatNaturalWoodworkCheckBox = new JCheckBox("Natural Woodwork");
        insideFeatNineFootCheckBox = new JCheckBox("9ft+ Ceilings");
        insideFeatRecessCeilingCheckBox = new JCheckBox("Recess Ceiling");
        insideFeatSolariumCheckBox = new JCheckBox("Solarium");
        insideFeatVaultCeilingCheckBox = new JCheckBox("Vaulted Ceiling");
        miscAirCleanerCheckBox = new JCheckBox("Air Cleaner");
        miscCableTvCheckBox = new JCheckBox("Cable TV");
        miscCeilingFanCheckBox = new JCheckBox("Ceiling Fan");
        miscCoinLaundryCheckBox = new JCheckBox("Coin Laundry");
        miscDehumidifierCheckBox = new JCheckBox("Dehumidifier");
        miscFountainCheckBox = new JCheckBox("Fountain");
        miscGarageDoorOpenerCheckBox = new JCheckBox("Garage Door Opnr");
        miscHighTextWiringCheckBox = new JCheckBox("High Tech Wiring");
        miscRecessLightCheckBox = new JCheckBox("Recess Light");
        miscSmokeAlarmCheckBox = new JCheckBox("Smoke Alarm");
        miscSumpPumpCheckBox = new JCheckBox("Sump Pump");
        miscWaterSoftenerCheckBox = new JCheckBox("Water Softener");
        outsideFeatBalconyCheckBox = new JCheckBox("Balcony");
        outsideFeatCornerLotCheckBox = new JCheckBox("Corner Lot");
        outsideFeatCoveredDeckCheckBox = new JCheckBox("Covered Deck");
        outsideFeatCulDeSacCheckBox = new JCheckBox("Cul-De-Sac");
        outsideFeatDeckCheckBox = new JCheckBox("Deck");
        outsideFeatEnclPorchCheckBox = new JCheckBox("Encl Patio/Porch");
        outsideFeatFlagLotCheckBox = new JCheckBox("Flag Lot");
        outsideFeatHotTubCheckBox = new JCheckBox("Hot Tub");
        outsideFeatInvisibleFenceCheckBox = new JCheckBox("Invisible Fence");
        outsideFeatMetalFenceCheckBox = new JCheckBox("Metal Fence");
        outsideFeatPatioCheckBox = new JCheckBox("Patio");
        outsideFeatPoolAboveCheckBox = new JCheckBox("Above Ground Pool");
        outsideFeatPoolIngroundCheckBox = new JCheckBox("Ingound Pool");
        outsideFeatPorchCheckBox = new JCheckBox("Porch");
        outsideFeatPrivacyFenceCheckBox = new JCheckBox("Privacy Fence");
        outsideFeatSprinklersCheckBox = new JCheckBox("BBQ Grill");
        outsideFeatTennisCourtCheckBox = new JCheckBox("Tennis Court");
        outsideFeatTieredDeckCheckBox = new JCheckBox("Tiered Deck");
        outsideFeatVinylFenceCheckBox = new JCheckBox("Vinyl Fence");
        outsideFeatWoodedLotCheckBox = new JCheckBox("Wooded Lot");
        outsideFeatWoodFenceCheckBox = new JCheckBox("Wood Fence");
        outsideFeatYardLightsCheckBox = new JCheckBox("Yard Lights");
        viewCityCheckBox = new JCheckBox("City");
        viewLakeCheckBox = new JCheckBox("Lake/Pond");
        viewParkCheckBox = new JCheckBox("Park");
        viewRiverCheckBox = new JCheckBox("River");
        viewWoodsCheckBox = new JCheckBox("Woods");
        zoningBusinessCheckBox = new JCheckBox("Business");
        zoningCommercialCheckBox = new JCheckBox("Commercial");
        zoningIndustrialCheckBox = new JCheckBox("Industrial");
        zoningMobileHomeCheckBox = new JCheckBox("Mobile Homes");
        zoningMultiFamilyCheckBox = new JCheckBox("Multi-Family");
        zoningNonconformingCheckBox = new JCheckBox("Nonconforming");
        zoningOfficeCheckBox = new JCheckBox("Office");
        zoningResidentialCheckBox = new JCheckBox("Residential");
        zoningUnzonedCheckBox = new JCheckBox("Unzoned");
        amenitiesLabel = new JLabel("Amenities");
        applianceLabel = new JLabel("Appliances");
        basementLabel = new JLabel("Basement Feat:");
        buildingLabel = new JLabel("Buildings");
        documentsLabel = new JLabel("Documents");
        insideFeaturesLabel = new JLabel("Inside Features");
        miscLabel = new JLabel("Miscellaneous");
        outsideFeaturesLabel = new JLabel("Outside Features");
        viewLabel = new JLabel("View");
        amenitiesPanel = new JPanel();
        appliancePanel = new JPanel();
        basementPanel = new JPanel();
        buildingPanel = new JPanel();
        documentsPanel = new JPanel();
        insideFeaturesPanel = new JPanel();
        miscPanel = new JPanel();
        outsideFeaturesPanel = new JPanel();
        propertFeaturePanel = new JPanel(new GridLayout(2, 2));
        viewPanel = new JPanel();
        roomList = new DefaultListModel();
        roomListHolder = new JList(roomList);
        listScroller = new JScrollPane(roomListHolder);
        listScroller.setPreferredSize(new Dimension(100, 100));
        ListSelectionModel listSelectionModel = roomListHolder.getSelectionModel();
        listSelectionModel.addListSelectionListener(this);

    }

    public void createTopLeftPanel() {
        topLeft.add(roomListHolder);
    }

    public void valueChanged(ListSelectionEvent e) {
        try {
            if (roomListHolder.getSelectedValue().equals("Amenities")) {
                topRight.removeAll();
                topRight.add(amenitiesPanel);
                this.revalidate();
                this.repaint();


            }

        } catch (Exception ex) {
        }
        try {
            if (roomListHolder.getSelectedValue().equals("Basement")) {
                topRight.removeAll();
                topRight.add(basementPanel);
                this.revalidate();
                this.repaint();
            }

        } catch (Exception ex) {
        }
        try {
            if (roomListHolder.getSelectedValue().equals("Building")) {
                topRight.removeAll();
                topRight.add(buildingPanel);
                this.revalidate();
                this.repaint();
            }

        } catch (Exception ex) {
        }
        try {
            if (roomListHolder.getSelectedValue().equals("View")) {
                topRight.removeAll();
                topRight.add(viewPanel);
                this.revalidate();
                this.repaint();
            }

        } catch (Exception ex) {
        }
        try {
            if (roomListHolder.getSelectedValue().equals("Zoning")) {
                topRight.removeAll();
                topRight.add(zoningPanel);
                this.revalidate();
                this.repaint();
            }

        } catch (Exception ex) {
        }
        try {
            if (roomListHolder.getSelectedValue().equals("Basement")) {
                topRight.removeAll();
                topRight.add(basementPanel);
                this.revalidate();
                this.repaint();
            }

        } catch (Exception ex) {
        }
        try {
            if (roomListHolder.getSelectedValue().equals("Documents")) {
                topRight.removeAll();
                topRight.add(documentsPanel);
                this.revalidate();
                this.repaint();
            }

        } catch (Exception ex) {
        }
        try {
            if (roomListHolder.getSelectedValue().equals("Inside Features")) {
                topRight.removeAll();
                topRight.add(insideFeaturesPanel);
                this.revalidate();
                this.repaint();
            }

        } catch (Exception ex) {
        }
        try {
            if (roomListHolder.getSelectedValue().equals("Outside Features")) {
                topRight.removeAll();
                topRight.add(outsideFeaturesPanel);
                this.revalidate();
                this.repaint();
            }

        } catch (Exception ex) {
        }
        try {
            if (roomListHolder.getSelectedValue().equals("Miscellaneous")) {
                topRight.removeAll();
                topRight.add(miscPanel);
                this.revalidate();
                this.repaint();
            }

        } catch (Exception ex) {
        }
        try {
            if (roomListHolder.getSelectedValue().equals("Appliances")) {
                topRight.removeAll();
                topRight.add(appliancePanel);
                this.revalidate();
                this.repaint();
            }

        } catch (Exception ex) {
        }
    }

    private void createRoomList() {
        roomList.addElement("Amenities");
        roomList.addElement("Appliances");
        roomList.addElement("Basement");
        roomList.addElement("Building");
        roomList.addElement("Documents");
        roomList.addElement("Inside Features");
        roomList.addElement("Miscellaneous");
        roomList.addElement("Outside Features");
        roomList.addElement("View");
        roomList.addElement("Zoning");

    }

    public void actionPerformed(ActionEvent e) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
}
